/**
 * 三维向量。
 */
export class Vector3 {
   /**
    * X分量。
    */
   public x: number;

   /**
    * Y分量。
    */
   public y: number;

   /**
    * Z分量。
    */
   public z: number;

   // /**
   //  * 构造处理。
   //  *
   //  * @certify 210926
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  */
   // public constructor(x?: number, y?: number, z?: number) {
   //    this.x = x || 0;
   //    this.y = y || 0;
   //    this.z = z || 0;
   // }

   // /**
   //  * 获得X分量。
   //  *
   //  * @return X分量
   //  */
   // public get X(): number {
   //    return this.x;
   // }

   // /**
   //  * 获得Y分量。
   //  *
   //  * @return Y分量
   //  */
   // public get Y(): number {
   //    return this.y;
   // }

   // /**
   //  * 获得Z分量。
   //  *
   //  * @return Z分量
   //  */
   // public get Z(): number {
   //    return this.z;
   // }

   // /**
   //  * 判断是否有效。
   //  *
   //  * @return 是否有效
   //  */
   // public isValid(): boolean {
   //    return !isNaN(this.x) && !isNaN(this.y) && !isNaN(this.z);
   // }

   // /**
   //  * 判断是否为空。
   //  *
   //  * @return 是否为空
   //  */
   // public isEmpty(): boolean {
   //    return (this.x == 0) && (this.y == 0) && (this.z == 0);
   // }

   // /**
   //  * 判断是否近似为空。
   //  *
   //  * @param tolerance 容差
   //  * @return 是否为空
   //  */
   // public isZero(tolerance: number = MathUtil.TOLERANCE): boolean {
   //    return MathUtil.isZero(this.x, tolerance) &&
   //       MathUtil.isZero(this.y, tolerance) &&
   //       MathUtil.isZero(this.z, tolerance);
   // }

   // /**
   //  * 判断是否近似为单位向量。
   //  *
   //  * @param tolerance 容差
   //  * @return 是否为单位向量
   //  */
   // public isNearNormal(tolerance: number = MathUtil.TOLERANCE): boolean {
   //    return MathUtil.isZero(this.x, tolerance) && MathUtil.isZero(this.y, tolerance) && MathUtil.nearlyEquals(this.z, 1, tolerance)
   //       || MathUtil.isZero(this.x, tolerance) && MathUtil.nearlyEquals(this.y, 1, tolerance) && MathUtil.isZero(this.z, tolerance)
   //       || MathUtil.nearlyEquals(this.x, 1, tolerance) && MathUtil.isZero(this.y, tolerance) && MathUtil.isZero(this.z, tolerance)
   //       || MathUtil.isZero(this.x, tolerance) && MathUtil.isZero(this.y, tolerance) && MathUtil.nearlyEquals(this.z, -1, tolerance)
   //       || MathUtil.isZero(this.x, tolerance) && MathUtil.nearlyEquals(this.y, -1, tolerance) && MathUtil.isZero(this.z, tolerance)
   //       || MathUtil.nearlyEquals(this.x, -1, tolerance) && MathUtil.isZero(this.y, tolerance) && MathUtil.isZero(this.z, tolerance);
   // }

   // /**
   //  * 判断是否相等。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 是否相等
   //  */
   // public equals(value: Value3): boolean {
   //    return (this.x == value.x) && (this.y == value.y) && (this.z == value.z);
   // }

   // /**
   //  * 判断是否近似相等。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @param tolerance 容差
   //  * @return 是否相等
   //  */
   // public nearlyEquals(value: Value3, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    return MathUtil.nearlyEquals(this.x, value.x, tolerance) &&
   //       MathUtil.nearlyEquals(this.y, value.y, tolerance) &&
   //       MathUtil.nearlyEquals(this.z, value.z, tolerance);
   // }

   // /**
   //  * 判断是否近似相等(距离判定)。
   //  *
   //  * @param value 数据
   //  * @param tolerance 容差
   //  * @return 是否相等
   //  */
   // public nearlyEqualsDistance(value: Value3, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    var dis = Vector3.distance(value, this);
   //    return dis <= tolerance;
   // }

   // /**
   //  * 判断是否为负。
   //  *
   //  * @param value 数据
   //  * @return 是否为负
   //  */
   // public equalsNegative(value: Value3): boolean {
   //    return (this.x == -value.x) && (this.y == -value.y) && (this.z == -value.z);
   // }

   // /**
   //  * 判断是否近似为负。
   //  *
   //  * @param value 数据
   //  * @param tolerance 容差
   //  * @return 是否为负
   //  */
   // public nearlyEqualsNegative(value: Value3, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    return MathUtil.nearlyEquals(this.x, -value.x, tolerance) &&
   //       MathUtil.nearlyEquals(this.y, -value.y, tolerance) &&
   //       MathUtil.nearlyEquals(this.z, -value.z, tolerance);
   // }

   // /**
   //  * 判断是否方向近似。
   //  *
   //  * @param value 数据
   //  * @param tolerance 容差
   //  * @return 是否为负
   //  */
   // public nearlyEqualsDirection(value: Value3, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    return this.nearlyEquals(value, tolerance)
   //       || this.nearlyEqualsNegative(value, tolerance);
   // }


   // /**
   //  * 判断是否相等。
   //  *
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @return 是否相等
   //  */
   // public equalsValue(x: number, y: number, z: number): boolean {
   //    return (this.x == x) && (this.y == y) && (this.z == z);
   // }

   // /**
   //  * 判断是否近似相等。
   //  *
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @param tolerance 容差
   //  * @return 是否相等
   //  */
   // public nearlyEqualsValue(x: number, y: number, z: number, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    return MathUtil.nearlyEquals(this.x, x, tolerance) &&
   //       MathUtil.nearlyEquals(this.y, y, tolerance) &&
   //       MathUtil.nearlyEquals(this.z, z, tolerance);
   // }

   // /**
   //  * 设置X分量。
   //  *
   //  * @param x X分量
   //  * @return 向量
   //  */
   // public setX(x: number): Vector3 {
   //    this.x = x;
   //    return this;
   // }

   // /**
   //  * 设置Y分量。
   //  *
   //  * @param y Y分量
   //  * @return 向量
   //  */
   // public setY(y: number): Vector3 {
   //    this.y = y;
   //    return this;
   // }

   // /**
   //  * 设置Z分量。
   //  *
   //  * @param z Z分量
   //  * @return 向量
   //  */
   // public setZ(z: number): Vector3 {
   //    this.z = z;
   //    return this;
   // }

   // /**
   //  * 设置数据。
   //  *
   //  * @certify 220725
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @return 向量
   //  */
   // public set(x?: number, y?: number, z?: number): Vector3 {
   //    if (x != null) {
   //       this.x = x;
   //    }
   //    if (y != null) {
   //       this.y = y;
   //    }
   //    if (z != null) {
   //       this.z = z;
   //    }
   //    return this;
   // }

   // /**
   //  * 设置二维数据。
   //  *
   //  * @param value 内容
   //  * @return 向量
   //  */
   // public setValue2(value: Value2): Vector3 {
   //    this.x = value.x;
   //    this.y = value.y;
   //    this.z = 0;
   //    return this;
   // }

   // /**
   //  * 设置数据。
   //  *
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public setScalar(value: number): Vector3 {
   //    this.x = value;
   //    this.y = value;
   //    this.z = value;
   //    return this;
   // }

   // /**
   //  * 获得组件内容。
   //  *
   //  * @param index 索引
   //  * @return 数据
   //  */
   // public getComponent(index: number): number {
   //    switch (index) {
   //       case 0:
   //          return this.x;
   //       case 1:
   //          return this.y;
   //       case 2:
   //          return this.z;
   //       default:
   //          throw new Fatal(this, 'Invalid component index.');
   //    }
   // }

   // /**
   //  * 设置组件内容。
   //  *
   //  * @param index 索引
   //  * @param value 数据
   //  */
   // public setComponent(index: number, value: number): void {
   //    switch (index) {
   //       case 0:
   //          this.x = value;
   //          break;
   //       case 1:
   //          this.y = value;
   //          break;
   //       case 2:
   //          this.z = value;
   //          break;
   //       default:
   //          throw new Fatal(this, 'Invalid component index.');
   //    }
   // }

   // /**
   //  * 接收数据内容。
   //  *
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public assign(value: Value2 | Value3): Vector3 {
   //    this.x = value.x;
   //    this.y = value.y;
   //    if (value instanceof Vector2) {
   //       this.z = 0;
   //    } else {
   //       this.z = (value as Value3).z;
   //    }
   //    return this;
   // }

   // /**
   //  * to2d。
   //  *
   //  * @return 向量
   //  */
   // public to2d(): Vector3 {
   //    return new Vector3(this.x, this.y, 0);
   // }

   // /**
   //  * toVector2。
   //  *
   //  * @return 向量
   //  */
   // public toVector2(): Vector2 {
   //    return new Vector2(this.x, this.y);
   // }

   // /**
   //  * 接收数据内容。
   //  *
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public copy(value: Value3): Vector3 {
   //    this.x = value.x;
   //    this.y = value.y;
   //    this.z = value.z;
   //    return this;
   // }

   // /**
   //  * 复制数据内容。
   //  *
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public copyTo(value: Value3): Vector3 {
   //    value.x = this.x;
   //    value.y = this.y;
   //    value.z = this.z;
   //    return this;
   // }

   // /**
   //  * 加运算处理。
   //  *
   //  * @certify 220326
   //  * @param scalar 内容
   //  * @return 向量
   //  */
   // public addScalar(scalar: number): Vector3 {
   //    this.x += scalar;
   //    this.y += scalar;
   //    this.z += scalar;
   //    return this;
   // }

   // /**
   //  * 单个数据相加处理。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public add(value: Value3): Vector3 {
   //    this.x += value.x;
   //    this.y += value.y;
   //    this.z += value.z;
   //    return this;
   // }

   // /**
   //  * 分量数据相加处理。
   //  *
   //  * @certify 220326
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @return 向量
   //  */
   // public addValue(x: number, y: number, z: number): Vector3 {
   //    this.x += x;
   //    this.y += y;
   //    this.z += z;
   //    return this;
   // }

   // /**
   //  * 单个数据相加处理。
   //  *
   //  * @param value 数据
   //  * @param ref
   //  * @return 向量
   //  */
   // public addTo(value: Value3, ref?: Vector3): Vector3 {
   //    ref = ref || new Vector3();
   //    ref.x = this.x + value.x;
   //    ref.y = this.y + value.y;
   //    ref.z = this.z + value.z;
   //    return ref;
   // }

   // /**
   //  * 分量数据相加处理。
   //  *
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @param ref
   //  * @return 向量
   //  */
   // public addValueTo(x: number, y: number, z: number, ref?: Vector3): Vector3 {
   //    ref = ref || new Vector3();
   //    ref.x = this.x + x;
   //    ref.y = this.y + y;
   //    ref.z = this.z + z;
   //    return ref;
   // }

   // /**
   //  * 比率数据相加处理。
   //  *
   //  * @param value 数据
   //  * @param scale 比率
   //  * @return 向量
   //  */
   // public addScaledVector(value: Value3, scale: number): Vector3 {
   //    this.x += value.x * scale;
   //    this.y += value.y * scale;
   //    this.z += value.z * scale;
   //    return this;
   // }

   // /**
   //  * 多个数据相加处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @return 向量
   //  */
   // public addVectors(value1: Value3, value2: Value3): Vector3 {
   //    this.x = value1.x + value2.x;
   //    this.y = value1.y + value2.y;
   //    this.z = value1.z + value2.z;
   //    return this;
   // }

   // /**
   //  * 数据相减处理。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public subScalar(value: number): Vector3 {
   //    this.x -= value;
   //    this.y -= value;
   //    this.z -= value;
   //    return this;
   // }

   // /**
   //  * 单个数据相减处理。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public sub(value: Value3): Vector3 {
   //    this.x -= value.x;
   //    this.y -= value.y;
   //    this.z -= value.z;
   //    return this;
   // }

   // /**
   //  * 分量数据相减处理。
   //  *
   //  * @certify 220326
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @return 向量
   //  */
   // public subValue(x: number, y: number, z: number): Vector3 {
   //    this.x -= x;
   //    this.y -= y;
   //    this.z -= z;
   //    return this;
   // }

   // /**
   //  * 单个数据相减处理。
   //  *
   //  * @param value 数据
   //  * @param ref
   //  * @return 向量
   //  */
   // public subTo(value: Value3, ref?: Vector3): Vector3 {
   //    ref = ref || new Vector3();
   //    ref.x = this.x - value.x;
   //    ref.y = this.y - value.y;
   //    ref.z = this.z - value.z;
   //    return ref;
   // }

   // /**
   //  * 分量数据相减处理。
   //  *
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @param ref
   //  * @return 向量
   //  */
   // public subValueTo(x: number, y: number, z: number, ref?: Vector3): Vector3 {
   //    ref = ref || new Vector3();
   //    ref.x = this.x - x;
   //    ref.y = this.y - y;
   //    ref.z = this.z - z;
   //    return ref;
   // }

   // /**
   //  * 多个数据相减处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @return 向量
   //  */
   // public subVectors(value1: Value3, value2: Value3): Vector3 {
   //    this.x = value1.x - value2.x;
   //    this.y = value1.y - value2.y;
   //    this.z = value1.z - value2.z;
   //    return this;
   // }

   // /**
   //  * 数据相乘处理。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public multiplyScalar(value: number): Vector3 {
   //    this.x *= value;
   //    this.y *= value;
   //    this.z *= value;
   //    return this;
   // }

   // /**
   //  * 单个数据相乘处理。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public multiply(value: Value3): Vector3 {
   //    this.x *= value.x;
   //    this.y *= value.y;
   //    this.z *= value.z;
   //    return this;
   // }

   // /**
   //  * 分量数据相乘处理。
   //  *
   //  * @certify 220326
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @return 向量
   //  */
   // public multiplyValue(x: number, y: number, z: number): Vector3 {
   //    this.x *= x;
   //    this.y *= y;
   //    this.z *= z;
   //    return this;
   // }

   // /**
   //  * 多个数据相乘处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @return 向量
   //  */
   // public multiplyVectors(value1: Value3, value2: Value3): Vector3 {
   //    this.x = value1.x * value2.x;
   //    this.y = value1.y * value2.y;
   //    this.z = value1.z * value2.z;
   //    return this;
   // }

   // /**
   //  * 除运算处理。
   //  *
   //  * @certify 220326
   //  * @param value 内容
   //  * @return 向量
   //  */
   // public divideScalar(value: number): Vector3 {
   //    var scalar = 1 / value;
   //    return this.multiplyScalar(scalar);
   // }

   // /**
   //  * 单个数据相除处理。
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public divide(value: Value3): Vector3 {
   //    this.x /= value.x;
   //    this.y /= value.y;
   //    this.z /= value.z;
   //    return this;
   // }

   // /**
   //  * 分量数据相除处理。
   //  *
   //  * @certify 220326
   //  * @param x X分量
   //  * @param y Y分量
   //  * @param z Z分量
   //  * @return 向量
   //  */
   // public divideValue(x: number, y: number, z: number): Vector3 {
   //    this.x /= x;
   //    this.y /= y;
   //    this.z /= z;
   //    return this;
   // }

   // /**
   //  * 获得长度。
   //  *
   //  * @return 长度
   //  */
   // public length(): number {
   //    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
   // }

   // /**
   //  * 获得平方长度。
   //  *
   //  * @return 长度
   //  */
   // public lengthSq(): number {
   //    return this.x * this.x + this.y * this.y + this.z * this.z;
   // }

   // /**
   //  * 获得平方长度。
   //  *
   //  * @return 长度
   //  */
   // public lengthSquared(): number {
   //    return this.x * this.x + this.y * this.y + this.z * this.z;
   // }

   // /**
   //  * 获得模长度。
   //  *
   //  * @return 长度
   //  */
   // public lengthManhattan(): number {
   //    return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
   // }

   // /**
   //  * 设置长度。
   //  *
   //  * @param length 长度
   //  * @return 向量
   //  */
   // public setLength(length: number): Vector3 {
   //    var currentLength = this.length();
   //    var rate = length / currentLength;
   //    return this.multiplyScalar(rate);
   // }

   // /**
   //  * 单位化处理。
   //  *
   //  * @certify 220326
   //  * @return 向量
   //  */
   // public normalize(): Vector3 {
   //    var length = this.length();
   //    if (length > 0) {
   //       this.divideScalar(length);
   //    }
   //    return this;
   // }

   // /**
   //  * 平面单位化处理。
   //  *
   //  * @return 向量
   //  */
   // public normalize2(): Vector3 {
   //    var length = Math.sqrt(this.x * this.x + this.y * this.y);
   //    var scale = 1 / length;
   //    this.x *= scale;
   //    this.y *= scale;
   //    return this;
   // }

   // /**
   //  * 平面单位化处理。
   //  *
   //  * @param length 长度
   //  * @return 向量
   //  */
   // public normalizeFromLength(length: number): Vector3 {
   //    if (length === 0 || length === 1.0) {
   //       return this;
   //    }
   //    return this.multiplyScalar(1.0 / length);
   // }

   // /**
   //  * 计算取反的数据。
   //  *
   //  * @certify 220326
   //  * @return 向量
   //  */
   // public negate(): Vector3 {
   //    this.x = -this.x;
   //    this.y = -this.y;
   //    this.z = -this.z;
   //    return this;
   // }

   // /**
   //  * 计算向下取整的数据。
   //  *
   //  * @return 向量
   //  */
   // public floor(): Vector3 {
   //    this.x = Math.floor(this.x);
   //    this.y = Math.floor(this.y);
   //    this.z = Math.floor(this.z);
   //    return this;
   // }

   // /**
   //  * 计算向上取整的数据。
   //  *
   //  * @return 向量
   //  */
   // public ceil(): Vector3 {
   //    this.x = Math.ceil(this.x);
   //    this.y = Math.ceil(this.y);
   //    this.z = Math.ceil(this.z);
   //    return this;
   // }

   // /**
   //  * 计算4舍5入的数据。
   //  *
   //  * @param precision 精度
   //  * @return 向量
   //  */
   // public round(precision: number = 0): Vector3 {
   //    this.x = Float32Util.round(this.x, precision);
   //    this.y = Float32Util.round(this.y, precision);
   //    this.z = Float32Util.round(this.z, precision);
   //    return this;
   // }

   // /**
   //  * 计算4舍5入的数据。
   //  *
   //  * @param precision 精度
   //  * @return 向量
   //  */
   // public trunc(precision: number = 6): Vector3 {
   //    this.x = Float32Util.trunc(this.x, precision);
   //    this.y = Float32Util.trunc(this.y, precision);
   //    this.z = Float32Util.trunc(this.z, precision);
   //    return this;
   // }

   // /**
   //  * 计算向0取整的数据。
   //  *
   //  * @return 向量
   //  */
   // public roundToZero(): Vector3 {
   //    this.x = (this.x < 0) ? Math.ceil(this.x) : Math.floor(this.x);
   //    this.y = (this.y < 0) ? Math.ceil(this.y) : Math.floor(this.y);
   //    this.z = (this.z < 0) ? Math.ceil(this.z) : Math.floor(this.z);
   //    return this;
   // }

   // /**
   //  * 获得朝向指定点的角度。
   //  *
   //  * @param point 顶点
   //  * @return 角度
   //  */
   // public angleTo(point: Vector3): number {
   //    var dotValue = this.dot(point);
   //    var theta = dotValue / (Math.sqrt(this.lengthSquared() * point.lengthSquared()));
   //    return Math.acos(MathUtil.clamp(theta, -1, 1));
   // }

   // /**
   //  * 获得到指定点的距离。
   //  *
   //  * @param point 顶点
   //  * @return 距离
   //  */
   // public distanceTo(point: Value3): number {
   //    return Math.sqrt(this.distanceToSquared(point));
   // }

   // /**
   //  * 获得到指定点的距离。
   //  *
   //  * @param point 顶点
   //  * @return 距离
   //  */
   // public distanceToSquared(point: Value3): number {
   //    var dx = this.x - point.x;
   //    var dy = this.y - point.y;
   //    var dz = this.z - point.z;
   //    return dx * dx + dy * dy + dz * dz;
   // }

   // /**
   //  * 设置最小数据。
   //  */
   // public setMin(): void {
   //    this.x = this.y = this.z = Number.MIN_VALUE;
   // }

   // /**
   //  * 计算最小数据。
   //  *
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public min(value: Value3): Vector3 {
   //    if (value.x < this.x) {
   //       this.x = value.x;
   //    }
   //    if (value.y < this.y) {
   //       this.y = value.y;
   //    }
   //    if (value.z < this.z) {
   //       this.z = value.z;
   //    }
   //    return this;
   // }

   // /**
   //  * 计算最小数据。
   //  *
   //  * @param x X坐标
   //  * @param y Y坐标
   //  * @param z Z坐标
   //  * @return 向量
   //  */
   // public minValue(x: number, y: number, z: number): Vector3 {
   //    if (x < this.x) {
   //       this.x = x;
   //    }
   //    if (y < this.y) {
   //       this.y = y;
   //    }
   //    if (z < this.z) {
   //       this.z = z;
   //    }
   //    return this;
   // }

   // /**
   //  * 设置最大数据。
   //  */
   // public setMax(): void {
   //    this.x = this.y = this.z = Number.MAX_VALUE;
   // }

   // /**
   //  * 计算最大数据。
   //  *
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public max(value: Value3): Vector3 {
   //    if (value.x > this.x) {
   //       this.x = value.x;
   //    }
   //    if (value.y > this.y) {
   //       this.y = value.y;
   //    }
   //    if (value.z > this.z) {
   //       this.z = value.z;
   //    }
   //    return this;
   // }

   // /**
   //  * 计算最大数据。
   //  *
   //  * @param x X坐标
   //  * @param y Y坐标
   //  * @param z Z坐标
   //  * @return 向量
   //  */
   // public maxValue(x: number, y: number, z: number): Vector3 {
   //    if (x > this.x) {
   //       this.x = x;
   //    }
   //    if (y > this.y) {
   //       this.y = y;
   //    }
   //    if (z > this.z) {
   //       this.z = z;
   //    }
   //    return this;
   // }

   // /**
   //  * 计算最小和最大之间数据。
   //  *
   //  * @param min 最小数据
   //  * @param max 最大数据
   //  * @return 向量
   //  */
   // public clamp(min: Value3, max: Value3): Vector3 {
   //    this.x = Math.max(min.x, Math.min(max.x, this.x));
   //    this.y = Math.max(min.y, Math.min(max.y, this.y));
   //    this.z = Math.max(min.z, Math.min(max.z, this.z));
   //    return this;
   // }

   // /**
   //  * 计算最小和最大之间数据。
   //  *
   //  * @param min 最小数据
   //  * @param max 最大数据
   //  * @return 向量
   //  */
   // public clampScalar(min: number, max: number): Vector3 {
   //    this.x = Math.max(min, Math.min(max, this.x));
   //    this.y = Math.max(min, Math.min(max, this.y));
   //    this.z = Math.max(min, Math.min(max, this.z));
   //    return this;
   // }

   // /**
   //  * 计算最小和最大之间长度。
   //  *
   //  * @param min 最小长度
   //  * @param max 最大长度
   //  * @return 向量
   //  */
   // public clampLength(min, max): Vector3 {
   //    var length = this.length();
   //    var rate = Math.max(min, Math.min(max, length)) / length;
   //    return this.multiplyScalar(rate);
   // }

   // /**
   //  * 计算点积处理。已知 力和位移 求功
   //  * 单位化后 的dot值 是两个向量夹角的cos值
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 数据
   //  */
   // public dot(value: Value3): number {
   //    return this.x * value.x + this.y * value.y + this.z * value.z;
   // }

   // /**
   //  * 计算叉积处理。 得到垂直于两个矢量的矢量
   //  *
   //  * @certify 220326
   //  * @param value 数据
   //  * @return 向量
   //  */
   // public cross(value: Value3): Vector3 {
   //    var x = this.x;
   //    var y = this.y;
   //    var z = this.z;
   //    this.x = y * value.z - z * value.y;
   //    this.y = z * value.x - x * value.z;
   //    this.z = x * value.y - y * value.x;
   //    return this;
   // }

   // /**
   //  * 计算叉积处理。
   //  *
   //  * @param left 数据1
   //  * @param right 数据2
   //  * @return 向量
   //  */
   // public crossVectors(left: Value3, right: Value3): Vector3 {
   //    var ax = left.x;
   //    var ay = left.y;
   //    var az = left.z;
   //    var bx = right.x;
   //    var by = right.y;
   //    var bz = right.z;
   //    this.x = ay * bz - az * by;
   //    this.y = az * bx - ax * bz;
   //    this.z = ax * by - ay * bx;
   //    return this;
   // }

   // /**
   //  * 三维向量的叉乘，返回与这个向量和另一个向量相正交的向量。
   //  *
   //  * @param value 另一个向量
   //  */
   // public crossVector(value: Vector3): Vector3 {
   //    var vec = this as Vector3;
   //    vec.cross(value);
   //    return vec;
   // }

   // /**
   //  * 计算两个单位向量的夹角。
   //  * this为X，normal为Y，value正方向为X->Y方向。
   //  *
   //  * @param value 内容
   //  * @param normal
   //  */
   // public angleNormal(value: Vector3, normal?: Vector3): number {
   //    var n = normal ? normal : Vector3.AxisZ;
   //    var r = Vector3.crossVectors(n, this);
   //    var cos = this.dot(value) as number;
   //    if (cos < -1.0) {
   //       cos = -1.0;
   //    } else if (cos > 1.0) {
   //       cos = 1.0;
   //    }
   //    var agle = Math.acos(cos);
   //    if (value.dot(r) >= 0) {
   //       return agle;
   //    } else {
   //       return -agle;
   //    }
   // }

   // /**
   //  * 计算两个空间向量的夹角。
   //  *
   //  * @param value 内容
   //  */
   // public angle(value: Vector3): number {
   //    var crs = this.dot(value) as number;
   //    var mod = (this.length() * value.length()) as number;
   //    var cos = crs / (mod + MathUtil.EPSILON);
   //    if (cos < -1.0) {
   //       cos = -1.0;
   //    } else if (cos > 1.0) {
   //       cos = 1.0;
   //    }
   //    return Math.acos(cos);
   // }

   // /**
   //  * 计算带参考向量的两个空间向量的夹角。
   //  *
   //  * @param value 内容
   //  * @param refVec
   //  */
   // public angleDeg(value: Vector3, refVec: Vector3): number {
   //    var vect = this.clone();
   //    vect.cross(value);
   //    if (refVec.dot(vect) < 1e-6) {
   //       return this.angle(value);
   //    } else {
   //       return Math.PI * 2 - this.angle(value);
   //    }
   // }

   // /**
   //  * 计算插值处理。
   //  *
   //  * @param value 数据
   //  * @param rate 比率
   //  * @return 向量
   //  */
   // public lerp(value: Value3, rate: number): Vector3 {
   //    this.x += (value.x - this.x) * rate;
   //    this.y += (value.y - this.y) * rate;
   //    this.z += (value.z - this.z) * rate;
   //    return this;
   // }

   // /**
   //  * 计算插值处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @param rate 比率
   //  * @return 向量
   //  */
   // public lerpVectors(value1: Value3, value2: Value3, rate: number): Vector3 {
   //    this.subVectors(value2, value1).multiplyScalar(rate).add(value1);
   //    return this;
   // }

   // /**
   //  * 计算当前向量在方向上的投影向量。
   //  *
   //  * @param value 向量
   //  * @param target 目标
   //  * @return 向量
   //  */
   // public projectOnVector(value: Vector3, target?: Vector3): Vector3 {
   //    // 计算比率
   //    var dot = value.dot(this);
   //    var lengthSquared = value.lengthSquared();
   //    var scalar = dot / lengthSquared;
   //    // 计算向量
   //    var result = target || new Vector3();
   //    result.assign(value);
   //    result.multiplyScalar(scalar);
   //    return result;
   // }

   // /**
   //  * 应用四元数。
   //  *
   //  * @param quaternion 四元数
   //  * @return 向量
   //  */
   // public applyQuaternion(quaternion: Quaternion): Vector3 {
   //    var x = this.x;
   //    var y = this.y;
   //    var z = this.z;
   //    var qx = quaternion.x;
   //    var qy = quaternion.y;
   //    var qz = quaternion.z;
   //    var qw = quaternion.w;
   //    var ix = qw * x + qy * z - qz * y;
   //    var iy = qw * y + qz * x - qx * z;
   //    var iz = qw * z + qx * y - qy * x;
   //    var iw = -qx * x - qy * y - qz * z;
   //    this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
   //    this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
   //    this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
   //    return this;
   // }

   // /**
   //  * 应用角度。
   //  *
   //  * @param euler 角度
   //  * @return 向量
   //  */
   // public applyEuler(euler: Euler): Vector3 {
   //    var quaternion = MemoryUtil.alloc(Quaternion) as Quaternion;
   //    quaternion.setFromEuler(euler);
   //    var result = this.applyQuaternion(quaternion);
   //    MemoryUtil.free(quaternion);
   //    return result;
   // }

   // /**
   //  * 应用轴角度。
   //  *
   //  * @param axis 轴
   //  * @param angle 角度
   //  * @return 向量
   //  */
   // public applyAxisAngle(axis: Value3, angle): Vector3 {
   //    var quaternion = MemoryUtil.alloc(Quaternion) as Quaternion;
   //    var result = this.applyQuaternion(quaternion.setFromAxisAngle(axis, angle));
   //    MemoryUtil.free(quaternion);
   //    return result;
   // }

   // /**
   //  * 应用三维矩阵变换。
   //  *
   //  * @certify 220326
   //  * @param matrix 矩阵
   //  * @return 向量
   //  */
   // public applyMatrix3(matrix: Matrix3): Vector3 {
   //    var x = this.x;
   //    var y = this.y;
   //    var z = this.z;
   //    var elements = matrix.elements;
   //    this.x = elements[0] * x + elements[3] * y + elements[6] * z;
   //    this.y = elements[1] * x + elements[4] * y + elements[7] * z;
   //    this.z = elements[2] * x + elements[5] * y + elements[8] * z;
   //    return this;
   // }

   // /**
   //  * 四维矩阵变换。
   //  *
   //  * @certify 220326
   //  * @param matrix 矩阵
   //  * @return 向量
   //  */
   // public applyMatrix4(matrix: Matrix4): Vector3 {
   //    var x = this.x;
   //    var y = this.y;
   //    var z = this.z;
   //    var e = matrix.elements;
   //    this.x = e[0] * x + e[4] * y + e[8] * z + e[12];
   //    this.y = e[1] * x + e[5] * y + e[9] * z + e[13];
   //    this.z = e[2] * x + e[6] * y + e[10] * z + e[14];
   //    return this;
   // }

   // /**
   //  * 四维矩阵中的旋转和缩放变换。
   //  *
   //  * @param matrix 矩阵
   //  * @return 向量
   //  */
   // public applyMatrix4NoTranslate(matrix: Matrix4): Vector3 {
   //    var x = this.x;
   //    var y = this.y;
   //    var z = this.z;
   //    var e = matrix.elements;
   //    this.x = e[0] * x + e[4] * y + e[8] * z;
   //    this.y = e[1] * x + e[5] * y + e[9] * z;
   //    this.z = e[2] * x + e[6] * y + e[10] * z;
   //    return this;
   // }

   // /**
   //  * 应用投影。
   //  *
   //  * @param matrix 矩阵
   //  * @return 向量
   //  */
   // public applyProjection(matrix: Matrix4): Vector3 {
   //    var x = this.x;
   //    var y = this.y;
   //    var z = this.z;
   //    var e = matrix.elements;
   //    var d = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
   //    this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * d;
   //    this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * d;
   //    this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * d;
   //    return this;
   // }

   // /**
   //  * X轴反转处理。
   //  *
   //  * @return 向量
   //  */
   // public flipX(): Vector3 {
   //    this.x = -this.x;
   //    return this;
   // }

   // /**
   //  * Y轴反转处理。
   //  *
   //  * @return 向量
   //  */
   // public flipY(): Vector3 {
   //    this.y = -this.y;
   //    return this;
   // }

   // /**
   //  * Z轴反转处理。
   //  *
   //  * @return 向量
   //  */
   // public flipZ(): Vector3 {
   //    this.z = -this.z;
   //    return this;
   // }

   // /**
   //  * 从数组中获得数据。
   //  *
   //  * @param array 数组
   //  * @param offset 位置
   //  * @return 向量
   //  */
   // public fromArray(array: Array<number>, offset: number = 0): Vector3 {
   //    this.x = array[offset];
   //    this.y = array[offset + 1];
   //    this.z = array[offset + 2];
   //    return this;
   // }

   // /**
   //  * 设置数据到数组中。
   //  *
   //  * @param array 数组
   //  * @param offset 位置
   //  * @return 数组
   //  */
   // public toArray(array?: Array<number>, offset: number = 0): Array<number> {
   //    if (array == null) {
   //       array = new Array<number>();
   //    }
   //    array[offset] = this.x;
   //    array[offset + 1] = this.y;
   //    array[offset + 2] = this.z;
   //    return array;
   // }

   // /**
   //  * 序列化数据到输出流里。
   //  *
   //  * @param output 数据流
   //  * @param dataCd 数据类型
   //  * @return 向量
   //  */
   // public serialize(output: IOutputStream, dataCd: DataTypeEnum = DataTypeEnum.Float64): Vector3 {
   //    switch (dataCd) {
   //       case DataTypeEnum.Int32:
   //          output.writeInt32(this.x);
   //          output.writeInt32(this.y);
   //          output.writeInt32(this.z);
   //          break;
   //       case DataTypeEnum.Float32:
   //          output.writeFloat32(this.x);
   //          output.writeFloat32(this.y);
   //          output.writeFloat32(this.z);
   //          break;
   //       case DataTypeEnum.Float64:
   //          output.writeFloat64(this.x);
   //          output.writeFloat64(this.y);
   //          output.writeFloat64(this.z);
   //          break;
   //       default:
   //          throw new Fatal(this, 'Serialize invalid.');
   //    }
   //    return this;
   // }

   // /**
   //  * 从输入流里反序列化数据。
   //  *
   //  * @param input 数据流
   //  * @param dataCd 数据类型
   //  * @return 向量
   //  */
   // public unserialize(input: IInputStream, dataCd: DataTypeEnum = DataTypeEnum.Float64): Vector3 {
   //    switch (dataCd) {
   //       case DataTypeEnum.Int32:
   //          this.x = input.readInt32();
   //          this.y = input.readInt32();
   //          this.z = input.readInt32();
   //          break;
   //       case DataTypeEnum.Float32:
   //          this.x = input.readFloat32();
   //          this.y = input.readFloat32();
   //          this.z = input.readFloat32();
   //          break;
   //       case DataTypeEnum.Float64:
   //          this.x = input.readFloat64();
   //          this.y = input.readFloat64();
   //          this.z = input.readFloat64();
   //          break;
   //       default:
   //          throw new Fatal(this, 'Unserialize invalid.');
   //    }
   //    return this;
   // }

   // /**
   //  * 解析字符串。
   //  *
   //  * @param value 字符串
   //  * @return 向量
   //  */
   // public parse(value: string): Vector3 {
   //    this.reset();
   //    if (!StringUtil.isEmpty(value)) {
   //       var items = value.split(',');
   //       if (items.length == 3) {
   //          this.x = parseFloat(items[0]);
   //          this.y = parseFloat(items[1]);
   //          this.z = parseFloat(items[2]);
   //          AssertUtil.debugNumber(this.x, this.y, this.z);
   //       } else {
   //          throw new Fatal(this, "Parse value failure. (value={1})", value);
   //       }
   //    }
   //    return this;
   // }

   // /**
   //  * 格式化为字符串。
   //  *
   //  * @param precision 精度
   //  * @return 字符串
   //  */
   // public format(precision: number = MathUtil.PRECISION): string {
   //    var x = Float32Util.round(this.x, precision);
   //    var y = Float32Util.round(this.y, precision);
   //    var z = Float32Util.round(this.z, precision);
   //    return x + ',' + y + ',' + z;
   // }

   // /**
   //  * 获得字符串。
   //  *
   //  * @return 字符串
   //  */
   // public toString(): string {
   //    return this.x + ',' + this.y + ',' + this.z;
   // }

   // /**
   //  * 释放内容。
   //  *
   //  * @certify 210926
   //  * @return 向量
   //  */
   // public free(): Vector3 {
   //    this.x = 0;
   //    this.y = 0;
   //    this.z = 0;
   //    return this;
   // }

   // /**
   //  * 克隆当前数据。
   //  *
   //  * @param type 类型
   //  * @return 向量
   //  */
   // public clone(type?: Function): Vector3 {
   //    var constructor = type || (this as any).constructor;
   //    return new constructor(this.x, this.y, this.z);
   //    // return new Vector3(this.x, this.y, this.z);
   // }

   // /**
   //  * 重置数据。
   //  *
   //  * @return 向量
   //  */
   // public reset(): Vector3 {
   //    this.x = 0;
   //    this.y = 0;
   //    this.z = 0;
   //    return this;
   // }

   // /**
   //  * 释放处理。
   //  */
   // public dispose(): void {
   //    this.x = null;
   //    this.y = null;
   //    this.z = null;
   // }
   // /** 零 */
   // public static Zero = new Vector3(0, 0, 0);
   // /** 原点 */
   // public static Origin = new Vector3(0, 0, 0);
   // /** 轴X */
   // public static AxisX = new Vector3(1, 0, 0);
   // /** 负轴X */
   // public static AxisNX = new Vector3(-1, 0, 0);
   // /** 轴Y */
   // public static AxisY = new Vector3(0, 1, 0);
   // /** 负轴Y */
   // public static AxisNY = new Vector3(0, -1, 0);
   // /** 轴Z */
   // public static AxisZ = new Vector3(0, 0, 1);
   // /** 负轴Z */
   // public static AxisNZ = new Vector3(0, 0, -1);
   // /** 单位 */
   // public static Unit = new Vector3(1, 1, 1);

   // /**
   //  * 根据数据获得对象。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @param value3 数据3
   //  * @return 向量
   //  */
   // public static from(value1?: any, value2?: any, value3?: any): Vector3 {
   //    var x = null;
   //    var y = null;
   //    var z = null;
   //    var count = arguments.length;
   //    if (count == 1) {
   //       var value = arguments[0];
   //       if (value instanceof Vector2) {
   //          x = value.x;
   //          y = value.y;
   //          z = 0;
   //       } else if (Array.isArray(value)) {
   //          x = value[0];
   //          y = value[1];
   //          z = value[2];
   //       } else {
   //          x = value.x;
   //          y = value.y;
   //          z = value.z;
   //       }
   //    } else if (count == 2) {
   //       var value1 = arguments[0];
   //       if (value1 instanceof Vector2) {
   //          x = value1.x;
   //          y = value1.y;
   //          z = arguments[1];
   //       } else {
   //          x = arguments[0];
   //          y = arguments[1];
   //          z = 0;
   //       }
   //    } else if (count == 3) {
   //       x = arguments[0];
   //       y = arguments[1];
   //       z = arguments[2];
   //    }
   //    AssertUtil.debugNumber(x, y, z);
   //    return new Vector3(x, y, z);
   // }

   // /**
   //  * 从二维数据中获得对象。
   //  *
   //  * @param value 二维数据
   //  * @param z Z轴内容
   //  * @return 向量
   //  */
   // public static fromValue2(value: Value2, z: number = 0): Vector3 {
   //    return new Vector3(value.x, value.y, z);
   // }

   // /**
   //  * 从UVW维度构造三维向量。
   //  *
   //  * @param u U维度
   //  * @param x X分量
   //  * @param v V维度
   //  * @param y Y分量
   //  * @param w W维度
   //  * @param z Z分量
   //  * @return 向量
   //  */
   // public static fromUvw(u: string, x: number, v: string, y: number, w: string, z: number): Vector3 {
   //    var value = new Vector3();
   //    value[u] = x;
   //    value[v] = y;
   //    value[w] = z;
   //    return value;
   // }

   // /**
   //  * 判断是否相等。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @return 是否相等
   //  */
   // public static equals(value1: Value3, value2: Value3): boolean {
   //    return (value1.x == value2.x) && (value1.y == value2.y) && (value1.z == value2.z);
   // }

   // /**
   //  * 判断是否相等。
   //  *
   //  * @param value 数据
   //  * @param x X数据
   //  * @param y Y数据
   //  * @param z Z数据
   //  * @return 是否相等
   //  */
   // public static equalsValue(value: Value3, x: number, y: number, z: number): boolean {
   //    return (value.x == x) && (value.y == y) && (value.z == z);
   // }

   // /**
   //  * 判断是否近似相等。
   //  *
   //  * @param value1 内容1
   //  * @param value2 内容2
   //  * @param tolerance 容差
   //  * @return 是否相等
   //  */
   // public static nearlyEquals(value1: Value3, value2: Value3, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    var ex = MathUtil.nearlyEquals(value1.x, value2.x, tolerance);
   //    var ey = MathUtil.nearlyEquals(value1.y, value2.y, tolerance);
   //    var ez = MathUtil.nearlyEquals(value1.z, value2.z, tolerance);
   //    return ex && ey && ez;
   // }

   // /**
   //  * 判断是否为负。
   //  *
   //  * @param value1 内容1
   //  * @param value2 内容2
   //  * @return 是否为负
   //  */
   // public static equalsNegative(value1: Value3, value2: Value3): boolean {
   //    return (value1.x == -value2.x) && (value1.y == -value2.y) && (value1.z == -value2.z);
   // }

   // /**
   //  * 判断是否近似为负。
   //  *
   //  * @param value1 内容1
   //  * @param value2 内容2
   //  * @param tolerance 容差
   //  * @return 是否为负
   //  */
   // public static nearlyEqualsNegative(value1: Value3, value2: Value3, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    return MathUtil.nearlyEquals(value1.x, -value2.x, tolerance) &&
   //       MathUtil.nearlyEquals(value1.y, -value2.y, tolerance) &&
   //       MathUtil.nearlyEquals(value1.z, -value2.z, tolerance);
   // }

   // /**
   //  * 数据相加处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @param target 目标
   //  * @return 向量
   //  */
   // public static add(value1: Value3, value2: Value3, target?: Vector3): Vector3 {
   //    var result = target || new Vector3();
   //    result.x = value1.x + value2.x;
   //    result.y = value1.y + value2.y;
   //    result.z = value1.z + value2.z;
   //    return result;
   // }

   // /**
   //  * 多个数据相加处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @return 向量
   //  */
   // public static addVectors(value1: Value3, value2: Value3): Vector3 {
   //    var cx = value1.x + value2.x;
   //    var cy = value1.y + value2.y;
   //    var cz = value1.z + value2.z;
   //    return new Vector3(cx, cy, cz);
   // }

   // /**
   //  * 数据相减处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @param target 目标
   //  * @return 向量
   //  */
   // public static sub(value1: Value3, value2: Value3, target?: Vector3): Vector3 {
   //    var result = target || new Vector3();
   //    result.x = value1.x - value2.x;
   //    result.y = value1.y - value2.y;
   //    result.z = value1.z - value2.z;
   //    return result;
   // }

   // /**
   //  * 多个数据相减处理。
   //  *
   //  * @param value1 数据1
   //  * @param value2 数据2
   //  * @param value3 数据3
   //  * @return 向量
   //  */
   // public static subVectors(value1: Value3, value2: Value3, value3?: Value3): Vector3 {
   //    var cx = value1.x - value2.x;
   //    var cy = value1.y - value2.y;
   //    var cz = value1.z - value2.z;
   //    if (value3) {
   //       cx -= value3.x;
   //       cy -= value3.y;
   //       cz -= value3.z;
   //    }
   //    return new Vector3(cx, cy, cz);
   // }

   // /**
   //  * 获得两点之间距离。
   //  *
   //  * @param point1 开始点
   //  * @param point2 结束点
   //  * @return 距离
   //  */
   // public static distance(point1: Value3, point2: Value3): number {
   //    var cx = point2.x - point1.x;
   //    var cy = point2.y - point1.y;
   //    var cz = point2.z - point1.z;
   //    return Math.sqrt(cx * cx + cy * cy + cz * cz);
   // }

   // /**
   //  * 获得两点之间距离。
   //  *
   //  * @param x1 开始点X坐标
   //  * @param y1 开始点Y坐标
   //  * @param z1 开始点Z坐标
   //  * @param x2 结束点X坐标
   //  * @param y2 结束点Y坐标
   //  * @param z2 结束点Z坐标
   //  * @return 距离
   //  */
   // public static distanceValue(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number {
   //    AssertUtil.debugNumber(x1, y1, z1, x2, y2, z2);
   //    var cx = x1 - x2;
   //    var cy = y1 - y2;
   //    var cz = z1 - z2;
   //    return Math.sqrt(cx * cx + cy * cy + cz * cz);
   // }

   // /**
   //  * 获得方向处理。
   //  *
   //  * @param start
   //  * @param end 结束
   //  * @return 方向
   //  */
   // public static direction(start: Vector3, end: Vector3): Vector3 {
   //    var cx = end.x - start.x;
   //    var cy = end.y - start.y;
   //    var cz = end.z - start.z;
   //    var direction = new Vector3(cx, cy, cz);
   //    direction.normalize();
   //    return direction;
   // }

   // /**
   //  * 获得两个点的中心点。
   //  *
   //  * @param point1 点1
   //  * @param point2 点2
   //  * @return 中心点
   //  */
   // public static middle(point1: Value3, point2: Value3): Vector3 {
   //    var x = point1.x + point2.x;
   //    var y = point1.y + point2.y;
   //    var z = point1.z + point2.z;
   //    return new Vector3(x * 0.5, y * 0.5, z * 0.5);
   // }

   // /**
   //  * 计算点乘处理。
   //  *
   //  * @param left 数据1
   //  * @param right 数据2
   //  * @return 数值
   //  */
   // public static dotVectors(left: Value3, right: Value3): number {
   //    return left.x * right.x + left.y * right.y + left.z * right.z;
   // }

   // /**
   //  * 计算差乘处理。
   //  *
   //  * @param left 数据1
   //  * @param right 数据2
   //  * @param target 目标
   //  * @return 方向
   //  */
   // public static crossVectors(left: Vector3, right: Vector3, target?: Vector3): Vector3 {
   //    var result = target || new Vector3();
   //    result.crossVectors(left, right);
   //    return result;
   // }

   // /**
   //  * 判断是否顶点集合中是否含有点。
   //  *
   //  * @param points 点集合
   //  * @param point 点
   //  * @return 是否含有
   //  */
   // public static contains(points: Array<Vector3>, point: Vector3): boolean {
   //    var count = points.length;
   //    for (var i = 0; i < count; i++) {
   //       var find = points[i];
   //       if (Vector3.equals(find, point)) {
   //          return true;
   //       }
   //    }
   //    return false;
   // }

   // /**
   //  * 判断是否顶点集合中是否近似含有点。
   //  *
   //  * @param points 点集合
   //  * @param point 点
   //  * @param tolerance 容差
   //  * @return 是否含有
   //  */
   // public static nearlyContains(points: Array<Vector3>, point: Vector3, tolerance: number = MathUtil.TOLERANCE): boolean {
   //    var count = points.length;
   //    for (var i = 0; i < count; i++) {
   //       var find = points[i];
   //       if (Vector3.nearlyEquals(find, point, tolerance)) {
   //          return true;
   //       }
   //    }
   //    return false;
   // }

   // /**
   //  * 从集合中获得指定点的索引。
   //  *
   //  * @param points 点集合
   //  * @param point 点
   //  * @return 索引位置
   //  */
   // public static indexOf(points: Array<Vector3>, point: Vector3): number {
   //    var count = points.length;
   //    for (var i = 0; i < count; i++) {
   //       var find = points[i];
   //       if (Vector3.equals(find, point)) {
   //          return i;
   //       }
   //    }
   //    return -1;
   // }

   // /**
   //  * 从集合中获得指定点的索引。
   //  *
   //  * @param points 点集合
   //  * @param point 点
   //  * @param tolerance 容差
   //  * @return 索引位置
   //  */
   // public static nearlyIndexOf(points: Array<Vector3>, point: Vector3, tolerance: number = MathUtil.TOLERANCE): number {
   //    var count = points.length;
   //    for (var i = 0; i < count; i++) {
   //       var find = points[i];
   //       if (Vector3.nearlyEquals(find, point, tolerance)) {
   //          return i;
   //       }
   //    }
   //    return -1;
   // }

   // /**
   //  * 获得非重复的点集合。
   //  *
   //  * @param points 点集合
   //  * @param tolerance 容差
   //  * @return 非重复点集合
   //  */
   // public static unique(points: Array<Vector3>, tolerance: number = MathUtil.TOLERANCE): Array<Vector3> {
   //    var result = new Array<Vector3>();
   //    var count = points.length;
   //    for (var j = 0; j < count; j++) {
   //       var point = points[j];
   //       if (!Vector3.nearlyContains(result, point)) {
   //          result.push(point);
   //       }
   //    }
   //    return result;
   // }

   // /**
   //  * 解析字符串。
   //  *
   //  * @param value 字符串
   //  * @return 向量
   //  */
   // public static parse(value: string): Vector3 {
   //    var result = new Vector3();
   //    result.parse(value);
   //    return result;
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param camera
   //  */
   // public project(camera): Vector3 {
   //    var matrix = MemoryUtil.alloc(Matrix4);
   //    matrix.multiplyMatrices(camera.projectionMatrix, matrix.getInverse(camera.matrixWorld));
   //    var result = this.applyProjection(matrix);
   //    MemoryUtil.free(matrix);
   //    return result;
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param camera
   //  */
   // public unproject(camera): Vector3 {
   //    var matrix = MemoryUtil.alloc(Matrix4);
   //    matrix.multiplyMatrices(camera.matrixWorld, matrix.getInverse(camera.projectionMatrix));
   //    var result = this.applyProjection(matrix);
   //    MemoryUtil.free(matrix);
   //    return result;
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param m
   //  */
   // public transformDirection(m): Vector3 {
   //    var x = this.x, y = this.y, z = this.z;
   //    var e = m.elements;
   //    this.x = e[0] * x + e[4] * y + e[8] * z;
   //    this.y = e[1] * x + e[5] * y + e[9] * z;
   //    this.z = e[2] * x + e[6] * y + e[10] * z;
   //    return this.normalize();
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param planeNormal
   //  */
   // public projectOnPlane(planeNormal): Vector3 {
   //    var vector = MemoryUtil.alloc(Vector3);
   //    vector.copy(this).projectOnVector(planeNormal);
   //    var result = this.sub(vector);
   //    MemoryUtil.free(vector);
   //    return result;
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param normal
   //  */
   // public reflect(normal): Vector3 {
   //    var vector = MemoryUtil.alloc(Vector3);
   //    var result = this.sub(vector.copy(normal).multiplyScalar(2 * this.dot(normal)));
   //    MemoryUtil.free(vector);
   //    return result;
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param s
   //  */
   // public setFromSpherical(s): Vector3 {
   //    var sinPhiRadius = Math.sin(s.phi) * s.radius;
   //    this.x = sinPhiRadius * Math.sin(s.theta);
   //    this.y = Math.cos(s.phi) * s.radius;
   //    this.z = sinPhiRadius * Math.cos(s.theta);
   //    return this;
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param m
   //  */
   // public setFromMatrixPosition(m): Vector3 {
   //    return this.setFromMatrixColumn(m, 3);
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param m
   //  */
   // public setFromMatrixScale(m): Vector3 {
   //    var sx = this.setFromMatrixColumn(m, 0).length();
   //    var sy = this.setFromMatrixColumn(m, 1).length();
   //    var sz = this.setFromMatrixColumn(m, 2).length();
   //    this.x = sx;
   //    this.y = sy;
   //    this.z = sz;
   //    return this;
   // }

   // /**
   //  * TODO。
   //  *
   //  * @param m
   //  * @param index 索引
   //  */
   // public setFromMatrixColumn(m, index): Vector3 {
   //    if (typeof m === 'number') {
   //       console.warn('setFromMatrixColumn now expects ( matrix, index ).');
   //       var temp = m;
   //       m = index;
   //       index = temp;
   //    }
   //    return this.fromArray(m.elements, index * 4);
   // }

   // /**
   //  * 计算一个线段和四角面相交的焦点。
   //  *
   //  * @param line 线段
   //  * @param face
   //  * @param target 目标盒子
   //  * @return 相交盒子
   //  */
   // public static intersectFace4(line: Array<Vector3>, face: Array<Vector3>, target?: Vector3): Vector3 {
   //    var result = target || new Vector3();
   //    return result;
   // }

   // /**
   //  * 转为一般向量。
   //  *
   //  * @return 一般向量
   //  */
   // public toVectorN(): VectorN {
   //    var rerult = new VectorN();
   //    rerult.push(this.x);
   //    rerult.push(this.y);
   //    rerult.push(this.z);
   //    return rerult;
   // }
}
